/*
 * This file contains miscellaneous pieces of code which regfio.c
 * depends upon, from the Samba Subversion tree.  See:
 *   http://websvn.samba.org/cgi-bin/viewcvs.cgi/trunk/source/
 *
 * Copyright (C) 2005 Timothy D. Morgan
 * Copyright (C) 1992-2005 Samba development team 
 *               (see individual files under Subversion for details.)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * $Id: smb_deps.c 53 2005-09-04 21:04:58Z tim $
 */

#include "../include/smb_deps.h"


/* These act as replacements for numerous Samba memory allocation
 *   functions. 
 */
void* zalloc(size_t size)
{
  void* ret_val = NULL;
  if((ret_val = (void*)malloc(size)) != NULL)
    memset(ret_val, 0, size);
  return ret_val;
}

void* zcalloc(size_t size, unsigned int count)
{
  return zalloc(size*count);
}

/* From lib/time.c */

/****************************************************************************
 Put a 8 byte filetime from a time_t
 This takes real GMT as input and converts to kludge-GMT
****************************************************************************/
void unix_to_nt_time(NTTIME *nt, time_t t)
{
	double d;

	if (t==0) {
		nt->low = 0;
		nt->high = 0;
		return;
	}
	if (t == TIME_T_MAX) {
		nt->low = 0xffffffff;
		nt->high = 0x7fffffff;
		return;
	}		
	if (t == -1) {
		nt->low = 0xffffffff;
		nt->high = 0xffffffff;
		return;
	}		

	/* this converts GMT to kludge-GMT */
	/*XXX t -= TimeDiff(t) - get_serverzone(); */

	d = (double)(t);
	d += TIME_FIXUP_CONSTANT;
	d *= 1.0e7;

	nt->high = (uint32)(d * (1.0/(4.0*(double)(1<<30))));
	nt->low  = (uint32)(d - ((double)nt->high)*4.0*(double)(1<<30));
}


/****************************************************************************
 Interpret an 8 byte "filetime" structure to a time_t
 It's originally in "100ns units since jan 1st 1601"

 An 8 byte value of 0xffffffffffffffff will be returned as (time_t)0.

 It appears to be kludge-GMT (at least for file listings). This means
 its the GMT you get by taking a localtime and adding the
 serverzone. This is NOT the same as GMT in some cases. This routine
 converts this to real GMT.
****************************************************************************/
time_t nt_time_to_unix(NTTIME *nt)
{
	double d;
	time_t ret;
	/* The next two lines are a fix needed for the 
		broken SCO compiler. JRA. */
	time_t l_time_min = TIME_T_MIN;
	time_t l_time_max = TIME_T_MAX;

	if (nt->high == 0 || (nt->high == 0xffffffff && nt->low == 0xffffffff))
		return(0);

	d = ((double)nt->high)*4.0*(double)(1<<30);
	d += (nt->low&0xFFF00000);
	d *= 1.0e-7;
 
	/* now adjust by 369 years to make the secs since 1970 */
	d -= TIME_FIXUP_CONSTANT;

	if (d <= l_time_min)
		return (l_time_min);

	if (d >= l_time_max)
		return (l_time_max);

	ret = (time_t)(d+0.5);

	/* this takes us from kludge-GMT to real GMT */
	/*XXX
	ret -= get_serverzone();
	ret += LocTimeDiff(ret);
	*/
	return(ret);
}


/* End of stuff from lib/time.c */

/* From parse_prs.c */

/*******************************************************************
 Attempt, if needed, to grow a data buffer.
 Also depends on the data stream mode (io).
 ********************************************************************/
bool prs_grow(prs_struct *ps, uint32 extra_space)
{
	uint32 new_size;
	char *new_data;

	ps->grow_size = MAX(ps->grow_size, ps->data_offset + extra_space);

	if(ps->data_offset + extra_space <= ps->buffer_size)
		return true;

	/*
	 * We cannot grow the buffer if we're not reading
	 * into the prs_struct, or if we don't own the memory.
	 */

	if(ps->io || !ps->is_dynamic) {
		return false;
	}
	
	/*
	 * Decide how much extra space we really need.
	 */

	extra_space -= (ps->buffer_size - ps->data_offset);
	if(ps->buffer_size == 0) {
		/*
		 * Ensure we have at least a PDU's length, or extra_space, whichever
		 * is greater.
		 */

		new_size = MAX(MAX_PDU_FRAG_LEN,extra_space);

		if((new_data = zalloc(new_size)) == NULL) {
			return false;
		}
		memset(new_data, '\0', (size_t)new_size );
	} else {
		/*
		 * If the current buffer size is bigger than the space needed, just 
		 * double it, else add extra_space.
		 */
		new_size = MAX(ps->buffer_size*2, ps->buffer_size + extra_space);		

		if ((new_data = (char*)realloc(ps->data_p, new_size)) == NULL) {
			return false;
		}

		memset(&new_data[ps->buffer_size], '\0', (size_t)(new_size - ps->buffer_size));
	}
	ps->buffer_size = new_size;
	ps->data_p = new_data;

	return true;
}


/*******************************************************************
 Align a the data_len to a multiple of align bytes - filling with
 zeros.
 ********************************************************************/
bool prs_align(prs_struct *ps)
{
	uint32 mod = ps->data_offset & (ps->align-1);

	if (ps->align != 0 && mod != 0) {
		uint32 extra_space = (ps->align - mod);
		if(!prs_grow(ps, extra_space))
			return false;
		memset(&ps->data_p[ps->data_offset], '\0', (size_t)extra_space);
		ps->data_offset += extra_space;
	}

	return true;
}


/**
 * Initialise an expandable parse structure.
 *
 * @param size Initial buffer size.  If >0, a new buffer will be
 * created with malloc().
 *
 * @return false if allocation fails, otherwise true.
 **/

bool prs_init(prs_struct *ps, uint32 size, void *ctx, bool io)
{
  memset(ps, 0, sizeof(prs_struct));
  ps->io = io;
  ps->bigendian_data = RPC_LITTLE_ENDIAN;
  ps->align = RPC_PARSE_ALIGN;
  ps->is_dynamic = false;
  ps->data_offset = 0;
  ps->buffer_size = 0;
  ps->data_p = NULL;
  ps->mem_ctx = ctx;
  
  if (size != 0) {
    ps->buffer_size = size;
    if((ps->data_p = (char *)zalloc((size_t)size)) == NULL) {
      return false;
    }
    memset(ps->data_p, '\0', (size_t)size);
    ps->is_dynamic = true; /* We own this memory. */
  }
  
  return true;
}


char *prs_mem_get(prs_struct *ps, uint32 extra_size)
{
	if(ps->io) {
		/*
		 * If reading, ensure that we can read the requested size item.
		 */
		if (ps->data_offset + extra_size > ps->buffer_size) {
			return NULL;
		}
	} else {
		/*
		 * Writing - grow the buffer if needed.
		 */
		if(!prs_grow(ps, extra_size))
			return NULL;
	}
	return &ps->data_p[ps->data_offset];
}


/*******************************************************************
 Stream a uint32.
 ********************************************************************/
bool prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
{
	char *q = prs_mem_get(ps, sizeof(uint32));
	if (q == NULL)
		return false;

	if (ps->io) {
		if (ps->bigendian_data)
			*data32 = RIVAL(q,0);
		else
			*data32 = IVAL(q,0);
	} else {
		if (ps->bigendian_data)
			RSIVAL(q,0,*data32);
		else
			SIVAL(q,0,*data32);
	}

	ps->data_offset += sizeof(uint32);

	return true;
}


/******************************************************************
 Stream an array of uint32s. Length is number of uint32s.
 ********************************************************************/
bool prs_uint32s(bool charmode, const char *name, prs_struct *ps, 
		 int depth, uint32 *data32s, int len)
{
	int i;
	char *q = prs_mem_get(ps, len * sizeof(uint32));
	if (q == NULL)
		return false;

	if (ps->io) {
		if (ps->bigendian_data) {
			for (i = 0; i < len; i++)
				data32s[i] = RIVAL(q, 4*i);
		} else {
			for (i = 0; i < len; i++)
				data32s[i] = IVAL(q, 4*i);
		}
	} else {
		if (ps->bigendian_data) {
			for (i = 0; i < len; i++)
				RSIVAL(q, 4*i, data32s[i]);
		} else {
			for (i = 0; i < len; i++)
				SIVAL(q, 4*i, data32s[i]);
		}
	}

	ps->data_offset += (len * sizeof(uint32));

	return true;
}


/*******************************************************************
 Stream a uint16.
 ********************************************************************/
bool prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16)
{
	char *q = prs_mem_get(ps, sizeof(uint16));
	if (q == NULL)
		return false;

	if (ps->io) {
		if (ps->bigendian_data)
			*data16 = RSVAL(q,0);
		else
			*data16 = SVAL(q,0);
	} else {
		if (ps->bigendian_data)
			RSSVAL(q,0,*data16);
		else
			SSVAL(q,0,*data16);
	}


	ps->data_offset += sizeof(uint16);

	return true;
}


/*******************************************************************
 prs_uint16 wrapper. Call this and it sets up a pointer to where the
 uint16 should be stored, or gets the size if reading.
 ********************************************************************/
bool prs_uint16_pre(const char *name, prs_struct *ps, int depth, 
		    uint16 *data16, uint32 *offset)
{
	*offset = ps->data_offset;
	if (ps->io) {
		/* reading. */
		return prs_uint16(name, ps, depth, data16);
	} else {
		char *q = prs_mem_get(ps, sizeof(uint16));
		if(q ==NULL)
			return false;
		ps->data_offset += sizeof(uint16);
	}
	return true;
}


/*******************************************************************
 prs_uint16 wrapper.  call this and it retrospectively stores the size.
 does nothing on reading, as that is already handled by ...._pre()
 ********************************************************************/
bool prs_uint16_post(const char *name, prs_struct *ps, int depth, 
		     uint16 *data16, uint32 ptr_uint16, uint32 start_offset)
{
	if (!ps->io) {
		/* 
		 * Writing - temporarily move the offset pointer.
		 */
		uint16 data_size = ps->data_offset - start_offset;
		uint32 old_offset = ps->data_offset;

		ps->data_offset = ptr_uint16;
		if(!prs_uint16(name, ps, depth, &data_size)) {
			ps->data_offset = old_offset;
			return false;
		}
		ps->data_offset = old_offset;
	} else {
		ps->data_offset = start_offset + (uint32)(*data16);
	}
	return true;
}


/*******************************************************************
 Stream a uint8.
 ********************************************************************/
bool prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
{
	char *q = prs_mem_get(ps, 1);
	if (q == NULL)
		return false;

    if (ps->io)
		*data8 = CVAL(q,0);
	else
		SCVAL(q,0,*data8);

	ps->data_offset += 1;

	return true;
}


/******************************************************************
 Stream an array of uint8s. Length is number of uint8s.
 ********************************************************************/
bool prs_uint8s(bool charmode, const char *name, prs_struct *ps, int depth, 
		uint8* data8s, int len)
{
	int i;
	char *q = prs_mem_get(ps, len);
	if (q == NULL)
		return false;

	if (ps->io) {
		for (i = 0; i < len; i++)
			data8s[i] = CVAL(q,i);
	} else {
		for (i = 0; i < len; i++)
			SCVAL(q, i, data8s[i]);
	}

	ps->data_offset += len;

	return true;
}


/*******************************************************************
 Set the current offset (external interface).
 ********************************************************************/
bool prs_set_offset(prs_struct *ps, uint32 offset)
{
	if(offset <= ps->data_offset) {
		ps->data_offset = offset;
		return true;
	}

	if(!prs_grow(ps, offset - ps->data_offset))
		return false;

	ps->data_offset = offset;
	return true;
}

/* End of stuff from parse_prs.c */

/* From rpc_parse/parse_misc.c */

/*******************************************************************
 Reads or writes a struct uuid
********************************************************************/
bool smb_io_uuid(const char *desc, struct uuid *uuid, 
		 prs_struct *ps, int depth)
{
	if (uuid == NULL)
		return false;
	depth++;

	if(!prs_uint32 ("data   ", ps, depth, &uuid->time_low))
		return false;
	if(!prs_uint16 ("data   ", ps, depth, &uuid->time_mid))
		return false;
	if(!prs_uint16 ("data   ", ps, depth, &uuid->time_hi_and_version))
		return false;

	if(!prs_uint8s (false, "data   ", ps, depth, uuid->clock_seq, sizeof(uuid->clock_seq)))
		return false;
	if(!prs_uint8s (false, "data   ", ps, depth, uuid->node, sizeof(uuid->node)))
		return false;

	return true;
}


/*******************************************************************
 Reads or writes an NTTIME structure.
********************************************************************/
bool smb_io_time(const char *desc, NTTIME *nttime, prs_struct *ps, int depth)
{
	if (nttime == NULL)
		return false;
	depth++;

	if(!prs_align(ps))
		return false;
	
	if(!prs_uint32("low ", ps, depth, &nttime->low)) /* low part */
		return false;
	if(!prs_uint32("high", ps, depth, &nttime->high)) /* high part */
		return false;

	return true;
}


/*******************************************************************
 Reads or writes a DOM_SID structure.
********************************************************************/
bool smb_io_dom_sid(const char *desc, DOM_SID *sid, prs_struct *ps, int depth)
{
	int i;

	if (sid == NULL)
		return false;
	depth++;

	if(!prs_uint8 ("sid_rev_num", ps, depth, &sid->sid_rev_num))
		return false;

	if(!prs_uint8 ("num_auths  ", ps, depth, &sid->num_auths))
		return false;

	for (i = 0; i < 6; i++)
	{
		fstring tmp;
		snprintf(tmp, sizeof(tmp) - 1, "id_auth[%d] ", i);
		if(!prs_uint8 (tmp, ps, depth, &sid->id_auth[i]))
			return false;
	}

	/* oops! XXXX should really issue a warning here... */
	if (sid->num_auths > MAXSUBAUTHS)
		sid->num_auths = MAXSUBAUTHS;

	if(!prs_uint32s(false, "sub_auths ", ps, depth, sid->sub_auths, sid->num_auths))
		return false;

	return true;
}

/* End of stuff from rpc_parse/parse_misc.c */

/* From lib/util_sid.c */

/*****************************************************************
 Calculates size of a sid.
*****************************************************************/  
size_t sid_size(const DOM_SID *sid)
{
	if (sid == NULL)
		return 0;

	return sid->num_auths * sizeof(uint32) + 8;
}


/*****************************************************************
 Compare the auth portion of two sids.
*****************************************************************/  
int sid_compare_auth(const DOM_SID *sid1, const DOM_SID *sid2)
{
	int i;

	if (sid1 == sid2)
		return 0;
	if (!sid1)
		return -1;
	if (!sid2)
		return 1;

	if (sid1->sid_rev_num != sid2->sid_rev_num)
		return sid1->sid_rev_num - sid2->sid_rev_num;

	for (i = 0; i < 6; i++)
		if (sid1->id_auth[i] != sid2->id_auth[i])
			return sid1->id_auth[i] - sid2->id_auth[i];

	return 0;
}


/*****************************************************************
 Compare two sids.
*****************************************************************/  
int sid_compare(const DOM_SID *sid1, const DOM_SID *sid2)
{
	int i;

	if (sid1 == sid2)
		return 0;
	if (!sid1)
		return -1;
	if (!sid2)
		return 1;

	/* Compare most likely different rids, first: i.e start at end */
	if (sid1->num_auths != sid2->num_auths)
		return sid1->num_auths - sid2->num_auths;

	for (i = sid1->num_auths-1; i >= 0; --i)
		if (sid1->sub_auths[i] != sid2->sub_auths[i])
			return sid1->sub_auths[i] - sid2->sub_auths[i];

	return sid_compare_auth(sid1, sid2);
}


/*****************************************************************
 Compare two sids.
*****************************************************************/  
bool sid_equal(const DOM_SID *sid1, const DOM_SID *sid2)
{
	return sid_compare(sid1, sid2) == 0;
}

/* End of stuff from lib/util_sid.c */

/* From lib/secace.c */

/*******************************************************************
 Check if ACE has OBJECT type.
********************************************************************/

bool sec_ace_object(uint8 type)
{
	if (type == SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT ||
            type == SEC_ACE_TYPE_ACCESS_DENIED_OBJECT ||
            type == SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT ||
            type == SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT) {
		return true;
	}
	return false;
}

/* End of stuff from lib/secace.c */

/* From rpc_parse/parse_sec.c */

/*******************************************************************
 Reads or writes a SEC_ACCESS structure.
********************************************************************/
bool sec_io_access(const char *desc, SEC_ACCESS *t, prs_struct *ps, int depth)
{
	if (t == NULL)
		return false;

	depth++;
	
	if(!prs_uint32("mask", ps, depth, &t->mask))
		return false;

	return true;
}


/*******************************************************************
 Reads or writes a SEC_ACE structure.
********************************************************************/
bool sec_io_ace(const char *desc, SEC_ACE *psa, prs_struct *ps, int depth)
{
	uint32 old_offset;
	uint32 offset_ace_size;

	if (psa == NULL)
		return false;

	depth++;
	
	old_offset = ps->data_offset;

	if(!prs_uint8("type ", ps, depth, &psa->type))
		return false;

	if(!prs_uint8("flags", ps, depth, &psa->flags))
		return false;

	if(!prs_uint16_pre("size ", ps, depth, &psa->size, &offset_ace_size))
		return false;

	if(!sec_io_access("info ", &psa->info, ps, depth))
		return false;

	/* check whether object access is present */
	if (!sec_ace_object(psa->type)) {
		if (!smb_io_dom_sid("trustee  ", &psa->trustee , ps, depth))
			return false;
	} else {
		if (!prs_uint32("obj_flags", ps, depth, &psa->obj_flags))
			return false;

		if (psa->obj_flags & SEC_ACE_OBJECT_PRESENT)
			if (!smb_io_uuid("obj_guid", &psa->obj_guid, ps,depth))
				return false;

		if (psa->obj_flags & SEC_ACE_OBJECT_INHERITED_PRESENT)
			if (!smb_io_uuid("inh_guid", &psa->inh_guid, ps,depth))
				return false;

		if(!smb_io_dom_sid("trustee  ", &psa->trustee , ps, depth))
			return false;
	}

	/* Theorectically an ACE can have a size greater than the
	   sum of its components. When marshalling, pad with extra null bytes up to the
	   correct size. */

	if (!ps->io && (psa->size > ps->data_offset - old_offset)) {
		uint32 extra_len = psa->size - (ps->data_offset - old_offset);
		uint32 i;
		uint8 c = 0;

		for (i = 0; i < extra_len; i++) {
			if (!prs_uint8("ace extra space", ps, depth, &c))
				return false;
		}
	}

	if(!prs_uint16_post("size ", ps, depth, &psa->size, offset_ace_size, old_offset))
		return false;

	return true;
}


/*******************************************************************
 Reads or writes a SEC_ACL structure.  

 First of the xx_io_xx functions that allocates its data structures
 for you as it reads them.
********************************************************************/
bool sec_io_acl(const char *desc, SEC_ACL **ppsa, prs_struct *ps, int depth)
{
	unsigned int i;
	uint32 old_offset;
	uint32 offset_acl_size;
	SEC_ACL *psa;

	/*
	 * Note that the size is always a multiple of 4 bytes due to the
	 * nature of the data structure.  Therefore the prs_align() calls
	 * have been removed as they through us off when doing two-layer
	 * marshalling such as in the printing code (RPC_BUFFER).  --jerry
	 */

	if (ppsa == NULL)
		return false;

	psa = *ppsa;

	if(ps->io && psa == NULL) {
		/*
		 * This is a read and we must allocate the stuct to read into.
		 */
	  if((psa = (SEC_ACL*)zalloc(sizeof(SEC_ACL))) == NULL)
			return false;
		*ppsa = psa;
	}

	depth++;
	
	old_offset = ps->data_offset;

	if(!prs_uint16("revision", ps, depth, &psa->revision))
		return false;

	if(!prs_uint16_pre("size     ", ps, depth, &psa->size, &offset_acl_size))
		return false;

	if(!prs_uint32("num_aces ", ps, depth, &psa->num_aces))
		return false;

	if (ps->io) {
		/*
		 * Even if the num_aces is zero, allocate memory as there's a difference
		 * between a non-present DACL (allow all access) and a DACL with no ACE's
		 * (allow no access).
		 */
	  if((psa->ace = (SEC_ACE*)zcalloc(sizeof(SEC_ACE), psa->num_aces+1)) == NULL)
			return false;
	}

	for (i = 0; i < psa->num_aces; i++) {
		fstring tmp;
		snprintf(tmp, sizeof(tmp)-1, "ace_list[%02d]: ", i);
		if(!sec_io_ace(tmp, &psa->ace[i], ps, depth))
			return false;
	}

	/* Theorectically an ACL can have a size greater than the
	   sum of its components. When marshalling, pad with extra null bytes up to the
	   correct size. */

	if (!ps->io && (psa->size > ps->data_offset - old_offset)) {
		uint32 extra_len = psa->size - (ps->data_offset - old_offset);
		uint8 c = 0;

		for (i = 0; i < extra_len; i++) {
			if (!prs_uint8("acl extra space", ps, depth, &c))
				return false;
		}
	}

	if(!prs_uint16_post("size     ", ps, depth, &psa->size, offset_acl_size, old_offset))
		return false;

	return true;
}


/*******************************************************************
 Reads or writes a SEC_DESC structure.
 If reading and the *ppsd = NULL, allocates the structure.
********************************************************************/
bool sec_io_desc(const char *desc, SEC_DESC **ppsd, prs_struct *ps, int depth)
{
	uint32 old_offset;
	uint32 max_offset = 0; /* after we're done, move offset to end */
	uint32 tmp_offset = 0;

	SEC_DESC *psd;

	if (ppsd == NULL)
		return false;

	psd = *ppsd;

	if (psd == NULL) {
		if(ps->io) {
		  if((psd = (SEC_DESC*)zalloc(sizeof(SEC_DESC))) == NULL)
				return false;
			*ppsd = psd;
		} else {
			/* Marshalling - just ignore. */
			return true;
		}
	}

	depth++;

	/* start of security descriptor stored for back-calc offset purposes */
	old_offset = ps->data_offset;

	if(!prs_uint16("revision ", ps, depth, &psd->revision))
		return false;

	if(!prs_uint16("type     ", ps, depth, &psd->type))
		return false;

	if (!ps->io) {
		uint32 offset = SEC_DESC_HEADER_SIZE;

		/*
		 * Work out the offsets here, as we write it out.
		 */

		if (psd->sacl != NULL) {
			psd->off_sacl = offset;
			offset += psd->sacl->size;
		} else {
			psd->off_sacl = 0;
		}

		if (psd->dacl != NULL) {
			psd->off_dacl = offset;
			offset += psd->dacl->size;
		} else {
			psd->off_dacl = 0;
		}

		if (psd->owner_sid != NULL) {
			psd->off_owner_sid = offset;
			offset += sid_size(psd->owner_sid);
		} else {
			psd->off_owner_sid = 0;
		}

		if (psd->grp_sid != NULL) {
			psd->off_grp_sid = offset;
			offset += sid_size(psd->grp_sid);
		} else {
			psd->off_grp_sid = 0;
		}
	}

	if(!prs_uint32("off_owner_sid", ps, depth, &psd->off_owner_sid))
		return false;

	if(!prs_uint32("off_grp_sid  ", ps, depth, &psd->off_grp_sid))
		return false;

	if(!prs_uint32("off_sacl     ", ps, depth, &psd->off_sacl))
		return false;

	if(!prs_uint32("off_dacl     ", ps, depth, &psd->off_dacl))
		return false;

	max_offset = MAX(max_offset, ps->data_offset);

	if (psd->off_owner_sid != 0) {

		tmp_offset = ps->data_offset;
		if(!prs_set_offset(ps, old_offset + psd->off_owner_sid))
			return false;

		if (ps->io) {
			/* reading */
		  if((psd->owner_sid = (DOM_SID*)zalloc(sizeof(DOM_SID))) == NULL)
				return false;
		}

		if(!smb_io_dom_sid("owner_sid ", psd->owner_sid , ps, depth))
			return false;

		max_offset = MAX(max_offset, ps->data_offset);

		if (!prs_set_offset(ps,tmp_offset))
			return false;
	}

	if (psd->off_grp_sid != 0) {

		tmp_offset = ps->data_offset;
		if(!prs_set_offset(ps, old_offset + psd->off_grp_sid))
			return false;

		if (ps->io) {
			/* reading */
			if((psd->grp_sid = (DOM_SID*)zalloc(sizeof(DOM_SID))) == NULL)
				return false;
		}

		if(!smb_io_dom_sid("grp_sid", psd->grp_sid, ps, depth))
			return false;
			
		max_offset = MAX(max_offset, ps->data_offset);

		if (!prs_set_offset(ps,tmp_offset))
			return false;
	}

	if ((psd->type & SEC_DESC_SACL_PRESENT) && psd->off_sacl) {
		tmp_offset = ps->data_offset;
		if(!prs_set_offset(ps, old_offset + psd->off_sacl))
			return false;
		if(!sec_io_acl("sacl", &psd->sacl, ps, depth))
			return false;
		max_offset = MAX(max_offset, ps->data_offset);
		if (!prs_set_offset(ps,tmp_offset))
			return false;
	}

	if ((psd->type & SEC_DESC_DACL_PRESENT) && psd->off_dacl != 0) {
		tmp_offset = ps->data_offset;
		if(!prs_set_offset(ps, old_offset + psd->off_dacl))
			return false;
		if(!sec_io_acl("dacl", &psd->dacl, ps, depth))
			return false;
		max_offset = MAX(max_offset, ps->data_offset);
		if (!prs_set_offset(ps,tmp_offset))
			return false;
	}

	if(!prs_set_offset(ps, max_offset))
		return false;

	return true;
}

/* End of stuff from rpc_parse/parse_sec.c */

/* From lib/secace.c */

/*******************************************************************
 Compares two SEC_ACE structures
********************************************************************/
bool sec_ace_equal(SEC_ACE *s1, SEC_ACE *s2)
{
	/* Trivial case */

	if (!s1 && !s2) return true;

	/* Check top level stuff */

	if (s1->type != s2->type || s1->flags != s2->flags ||
	    s1->info.mask != s2->info.mask) {
		return false;
	}

	/* Check SID */

	if (!sid_equal(&s1->trustee, &s2->trustee)) {
		return false;
	}

	return true;
}

/* End of stuff from lib/secace.c */

/* From lib/secacl.c */

/*******************************************************************
 Compares two SEC_ACL structures
********************************************************************/

bool sec_acl_equal(SEC_ACL *s1, SEC_ACL *s2)
{
	unsigned int i, j;

	/* Trivial cases */

	if (!s1 && !s2) return true;
	if (!s1 || !s2) return false;

	/* Check top level stuff */

	if (s1->revision != s2->revision) {
		return false;
	}

	if (s1->num_aces != s2->num_aces) {
		return false;
	}

	/* The ACEs could be in any order so check each ACE in s1 against 
	   each ACE in s2. */

	for (i = 0; i < s1->num_aces; i++) {
		bool found = false;

		for (j = 0; j < s2->num_aces; j++) {
			if (sec_ace_equal(&s1->ace[i], &s2->ace[j])) {
				found = true;
				break;
			}
		}

		if (!found) return false;
	}

	return true;
}

/* End of stuff from lib/secacl.c */

/* From lib/secdesc.c */

/*******************************************************************
 Compares two SEC_DESC structures
********************************************************************/
bool sec_desc_equal(SEC_DESC *s1, SEC_DESC *s2)
{
	/* Trivial case */

	if (!s1 && !s2) {
		goto done;
	}

	/* Check top level stuff */

	if (s1->revision != s2->revision) {
		return false;
	}

	if (s1->type!= s2->type) {
		return false;
	}

	/* Check owner and group */

	if (!sid_equal(s1->owner_sid, s2->owner_sid)) {
		return false;
	}

	if (!sid_equal(s1->grp_sid, s2->grp_sid)) {
		return false;
	}

	/* Check ACLs present in one but not the other */

	if ((s1->dacl && !s2->dacl) || (!s1->dacl && s2->dacl) ||
	    (s1->sacl && !s2->sacl) || (!s1->sacl && s2->sacl)) 
	{
		return false;
	}

	/* Sigh - we have to do it the hard way by iterating over all
	   the ACEs in the ACLs */

	if (!sec_acl_equal(s1->dacl, s2->dacl) ||
	    !sec_acl_equal(s1->sacl, s2->sacl)) 
	{
		return false;
	}

 done:
	return true;
}

/* End of stuff from lib/secdesc.c */
